#!/usr/bin/env python
# -*-coding: utf-8 -*-
# Filename: buscar_intervenciones.py

##
# Módulos del sistema
try:
    import pygtk
    pygtk.require("2.0")
    import gtk
    import gtk.glade
except ImportError, error:
    print error
    print "Necesitas la librería gráficas gtk+pygtk"
from datetime import datetime

##
# Mósulos propios
try:
    from gui.msj_retroalimentacion import MensajeDeAdvertencia, MensajeDeError
    from lib.database import Intervencion, Ticket, Empleado
    from lib.funciones_utiles import add_find_column, close
    from gui.editar_estado_intervencion import EditarEstadoIntervencion
    from gui.agregar_comentarios_intervencion import AgregarComentariosIntervencion
except ImportError, error:
    print error
    print "Error en buscar_intervencines"
class BuscarIntervenciones:
    def __init__(self, padre):
        self.padre = padre
        self.hbox_90 = self.padre.wTree.get_widget("hbox90")
        self.hbox_93 = self.padre.wTree.get_widget("hbox93")
        #Variables de instancia
        #Spin button
        self.fecha_desde_dia = self.padre.wTree.get_widget("spinbutton16")
        self.fecha_desde_mes = self.padre.wTree.get_widget("spinbutton18")
        self.fecha_desde_anio = self.padre.wTree.get_widget("spinbutton14")
        self.fecha_hasta_dia = self.padre.wTree.get_widget("spinbutton15")
        self.fecha_hasta_mes = self.padre.wTree.get_widget("spinbutton17")
        self.fecha_hasta_anio = self.padre.wTree.get_widget("spinbutton19")
        self.fecha_actual_spin_button()
        #entry
        self.entry_ticket = self.padre.wTree.get_widget("entry23")
        self.entry_legajo = self.padre.wTree.get_widget("entry24")
        self.combo_estado = self.padre.wTree.get_widget("combobox12")
        self.combo_estado.set_model(gtk.ListStore(str))
        self.armar_combo()
        self.tree_resultado = self.padre.wTree.get_widget("treeview41")
        self.lista_resultado = gtk.ListStore(str, str, str, str,str, str, str,
                str, str)
        self.tree_resultado.set_model(self.lista_resultado)
        self.lista_resultado.clear()
        self.armar_lista_resultado()
        self.lista_intervenciones = []
        self.ticket = None
        self.empleado = None
        self.estado = None
        self.bandera = True

    def fecha_actual_spin_button(self):
        fecha_actual = datetime.now()
        self.fecha_hasta_dia.set_value(float(fecha_actual.day))
        self.fecha_hasta_mes.set_value(float(fecha_actual.month))
        self.fecha_hasta_anio.set_value(float(fecha_actual.year))

    def armar_lista_resultado(self):
        """Obtiene el tree view y arma las cabeceras de las columnas"""
        lista = ("Ticket", "Legajo", "Clasificacion\nactual", "Estado",
                "Fecha apertura", "Estado intervencion",
                "Fecha de\n asignacion", "Grupo interventor",
                "Observaciones")
        for pos, titulo in enumerate(lista):
            add_find_column(titulo, pos, self.tree_resultado)

    def armar_combo(self):
        """
        Estados de la intervencion:
        * Trabajando: estoy tratando el problema
        * Resuelta: solucionado el problema
        * En espera por grupo: necesito la intervencion de otro grupo
        * en espera por trabajar: esperando el comienzo del tranajo
        """
        estados = ("TODOS", "Trabajando",
                "En espera por grupo",
                "En espera por trabajar",
                "Resuelta",
                "Finalizada")
        for estado in estados:
            self.combo_estado.append_text(estado)
        self.combo_estado.set_active(0)

    def armar_fechas(self):
        """Toma los datos de los spin button y arma las fechas"""
        #Armamos las fechas
        self.fecha_desde = datetime(self.fecha_desde_anio.get_value_as_int(),
                self.fecha_desde_mes.get_value_as_int(),
                self.fecha_desde_dia.get_value_as_int())
        self.fecha_hasta = datetime(self.fecha_hasta_anio.get_value_as_int(),
                self.fecha_hasta_mes.get_value_as_int(),
                self.fecha_hasta_dia.get_value_as_int())

    def buscar_intervenciones(self, widget=None):
        """Busca las intervenciones desde la BD"""
        self.armar_fechas()
        self.lista_resultado.clear()
        print "Llegue"
        if self.sin_criterios():
            print "Hacemos un gran select"
            intervenciones = list(Intervencion.select())
            # Si no existe una intervencion en la BD muestro el error
            if intervenciones:
                self.mostrar_resultado(intervenciones)
            else:
                error = "No existen intervenciones con estos criterios"
                msj = MensajeDeError(error, self.padre.window)
                msj.run()
        else:
            lista_widget = [self.entry_ticket.get_text(),
                    self.entry_legajo.get_text()]
            # Caso que tengamos el numero de legajo y el nro de ticket
            if lista_widget[0] and lista_widget[1]:
                self.obtener_ticket(lista_widget[0])
                self.obtener_empleado(lista_widget[1])
                self.armar_resultado()
            elif lista_widget[0]:
                self.obtener_ticket(lista_widget[0])
                self.armar_resultado()
            elif lista_widget[1]:
                self.obtener_empleado(lista_widget[1])
                self.armar_resultado()
            else:
                self.obtener_estado(self.combo_estado.get_active_text())
                self.armar_resultado()

    def obtener_estado(self, estado):
        """Busca las intervenciones con estado = estado"""
        resultado = list(Intervencion.selectBy(estado=estado))
        if resultado:
            self.estado = resultado
        else:
            error = "No existen intervenciones con ese estado"
            msj =  MensajeDeError(error, self.padre.window)
            msj.run()
            self.combo_estado.set_active(0)

    def obtener_ticket(self, numero):
        try:
            self.ticket = Ticket.selectBy(numero_ticket=int(numero))[0]
        except IndexError, error:
            texto = "No existe ticket con ese numero"
            msj = MensajeDeError(texto, self.padre.window)
            msj.run()
            self.entry_ticket.set_text('')
    
    def obtener_empleado(self, legajo):
        try:
            self.empleado = Empleado.selectBy(legajo=int(legajo))[0]
        except IndexError, error:
            texto = "No existe el legajo en el sitema personal."
            msj = MensajeDeError(texto, self.padre.window)
            msj.run()
            self.entry_legajo.set_text('')

    def armar_resultado(self):
        # Si tengo solo legajo el resultado es self.empleado.tickets
        if self.ticket and self.empleado:
            #Busco las intervenciones de este emplado con ese numero
            print "Busco las intervenciones de este emplado con ese numero"
            intervenciones = []
            index = self.empleado.tickets_reclamados.index(self.ticket)
            ticket = self.empleado.tickets_reclamados[index]
            # Si las fechas son iguales buscamos las intervenciones de
            # ese dia
            if (self.fecha_desde == self.fecha_hasta):
                for intervencion in ticket.intervenciones:
                    if intervencion.fecha.date() == self.fecha_desde.date():
                        intervenciones.append(intervencion)
                if intervenciones:
                    self.mostrar_resultado(intervenciones)
                else:
                    self.no_existen_intervenciones()
            else:
                # Buscamos por el rango de fechas
                for intervencion in ticket.intervenciones:
                    if (intervencion.fecha.date() >= self.fecha_desde.date() and
                            intervencion.fecha.date() <= self.fecha_hasta.date()):
                        intervenciones.append(intervencion)
                if intervenciones:
                    self.mostrar_resultado(intervenciones)
                else:
                    self.no_existen_intervenciones()
        elif self.ticket:
            # Tenemos solo el ticket: devolvemos todas las
            # intervenciones asociadas al ticket
            print "Tenemos solo el ticket: devolvemos todas las ..."
            intervenciones = []
            if (self.fecha_desde == self.fecha_hasta):
                for intervencion in self.ticket.intervenciones:
                    if (intervencion.fecha.date() ==
                            self.fecha_desde.date()):
                        intervenciones.append(intervencion)
                if intervenciones:
                    self.mostrar_resultado(intervenciones)
                else:
                    self.no_existen_intervenciones()
            else:
                # Buscamos por el rango de fechas
                for intervencion in self.ticket.intervenciones:
                    if (intervencion.fecha.date() >= self.fecha_desde.date() and
                            intervencion.fecha.date() <= self.fecha_hasta.date()):
                        intervenciones.append(intervencion)
                if intervenciones:
                    self.mostrar_resultado(intervenciones)
                else:
                    self.no_existen_intervenciones()
        elif self.empleado:
            #Buscamos todas las intervenciones del empleado
            print "Tenemos solo el empleado..."
            intervenciones = []
            if (self.fecha_desde.date() == self.fecha_hasta.date()):
                for ticket in self.empleado.tickets_reclamados:
                    for intervencion in ticket.intervenciones:
                        if intervencion.fecha.date() == self.fecha_desde.date():
                            intervenciones.append(intervencion)
                if intervenciones:
                    self.mostrar_resultado(intervenciones)
                else:
                    self.no_existen_intervenciones()
            else:
                # Buscamos por el rango de fechas
                for ticket in self.empleado.tickets_reclamados:
                    for intervencion in ticket.intervenciones:
                        if (intervencion.fecha.date() >= self.fecha_desde.date() and
                                intervencion.fecha.date() <= self.fecha_hasta.date()):
                            intervenciones.append(intervencion)
                if intervenciones:
                    self.mostrar_resultado(intervenciones)
                else:
                    self.no_existen_intervenciones()
        elif self.estado:
            print "Tenemos estado de la intervencion. Ahora depuremos x fecha"
            #self.mostrar_resultado(self.estado)
            intervenciones = []
            if (self.fecha_desde.date() == self.fecha_hasta.date()):
                # Buscamos solo por un día
                print "Buscamos por estado y solo un día"
                for intervencion in self.estado:
                    if intervencion.fecha.date() == self.fecha_desde.date():
                        intervenciones.append(intervencion)
                if intervenciones:
                    self.mostrar_resultado(intervenciones)
                else:
                    self.no_existen_intervenciones()
            else:
                # Buscamos por el rango de fechas
                print "Buscamos por estado y por rango de fechas"
                for intervencion in self.estado:
                    if(intervencion.fecha.date() >= self.fecha_desde.date() and
                            intervencion.fecha.date() <= self.fecha_hasta.date()):
                        intervenciones.append(intervencion)
                if intervenciones:
                    self.mostrar_resultado(intervenciones)
                else:
                    self.no_existen_intervenciones()

    def no_existen_intervenciones(self):
        """Mensaje de error por no encontrar intervenciones con esos
        criterios"""
        error = "No existen intervenciones con esos criterios."
        msj = MensajeDeError(error, self.padre.window)
        self.fecha_actual_spin_button()
        msj.run()

    def mostrar_criterios_de_busqueda(self):
        """Completa los datos estáticos"""
        # Estado
        self.padre.wTree.get_widget("label477").set_text(
                self.combo_estado.get_active_text())
        # Ticket
        if self.ticket:
            self.padre.wTree.get_widget("label501").set_text(
                    str(self.ticket.numero_ticket))
        else:
            self.padre.wTree.get_widget("label501").set_text('--')
        # Empleado
        if self.empleado:
            self.padre.wTree.get_widget("label502").set_text(
                    self.empleado.legajo)
        else:
            self.padre.wTree.get_widget("label502").set_text('--')
        # Fechas
        self.padre.wTree.get_widget("label495").set_text(
                self.fecha_desde.strftime("%d-%m-%Y"))
        self.padre.wTree.get_widget("label496").set_text(
                self.fecha_hasta.strftime("%d-%m-%Y"))
        
            
    def mostrar_resultado(self, intervenciones):
        """Arma la lista_resultado"""
        self.mostrar_criterios_de_busqueda()
        self.lista_resultado.clear()
        for intervencion in intervenciones:
            #pdb.set_trace()
            observacion = ''
            if intervencion.observaciones:
                observacion = intervencion.observaciones[-1].descripcion
            lista = [intervencion.ticket.numero_ticket,
                    intervencion.ticket.empleado.legajo,
                    intervencion.ticket.clasificacion_actual.nombre,
                    intervencion.ticket.estado_actual.nombre,
                    intervencion.ticket.fecha_creacion.strftime("%d-%m-%Y"),
                    intervencion.estado,
                    intervencion.fecha.strftime("%d-%m-%Y"),
                    intervencion.grupo_de_resolucion.nombre,
                    observacion]
            #pdb.set_trace()
            self.lista_resultado.append(lista)
            if self.bandera:
                # Esta bandera facilita recargar la lista resultado despues de
                # haber hecho un cambio de estado en alguna intervencion.
                self.lista_intervenciones.append(intervencion)
        self.bandera = False
        self.hbox_90.hide()
        self.hbox_93.show()

    def sin_criterios(self):
        """Pregunta uno a uno de los widget de entrada si tienen datos.
        Retorna True si al menos uno tiene"""
        if (self.entry_ticket.get_text() or
                self.entry_legajo.get_text() or
                self.combo_estado.get_active_text() != "TODOS"):
            return False
        else:
            return True # quiere decir que no puso ni 

    def limpiar_campos(self, widget=None):
        lista_entry = (self.entry_ticket, self.entry_legajo)

        for entry in lista_entry:
            entry.set_text('')
        self.combo_estado.set_active(0)
        self.cleane_spin()
        
    def cleane_spin(self):
        """Pone los spin button en sus valores de default."""
        lista_spin_1 = [self.fecha_desde_dia, self.fecha_desde_mes,
                self.fecha_hasta_dia, self.fecha_hasta_mes]
        lista_spin_1999 = [self.fecha_desde_anio, self.fecha_hasta_anio]
        for spin in lista_spin_1:
            spin.set_value(1)
        for spin in lista_spin_1999:
            spin.set_value(1999)
        self.fecha_actual_spin_button()

    def aceptar(self, widget=None):
        self.hbox_90.show()
        self.hbox_93.hide()
        self.lista_resultado.clear()
        self.limpiar_campos(None)

    def agregar_observaciones(self, widget=None):
        model, path = self.tree_resultado.get_selection().get_selected_rows()
        if path:
            pos, = path[0]
            if (self.lista_intervenciones[pos].estado == 'Trabajando' and
                    self.lista_intervenciones[pos].ticket.grupo_de_resolucion.nombre ==
                    self.padre.grupo_de_resolucion.nombre):
                self.agregar_comentarios = AgregarComentariosIntervencion(self,
                    self.lista_intervenciones[pos])
            else:
                error = ("Para agregar comentarios, la intervencion debe estar",
                        "en estado 'Trabajando'.",
                        "Y ser el grupo de resolucion que la tiene asignada")
                msj = MensajeDeError("\n".join(error), self.padre.window)
                msj.run()
        else:
            error = "Para Agregar un comentario debe seleccionar la intervencion"
            msj = MensajeDeError(error, self.padre.window)
            msj.run()

    def editar_estado(self, widget=None):
        model, path = self.tree_resultado.get_selection().get_selected_rows()
        if path:
            pos, = path[0]
            # Verificacion especificada en el caso de uso. && el estado de la
            # intervencion es != 'Resuelta
            print self.lista_intervenciones[pos]
            #import pdb
            #pdb.set_trace()
            if(self.lista_intervenciones[pos].ticket.grupo_de_resolucion.nombre ==
                    self.padre.grupo_de_resolucion.nombre and
                    self.lista_intervenciones[pos].estado != 'Resuelta' and
                    self.lista_intervenciones[pos].estado != 'Finalizada'):
                print "Puedo modificar el estado"
                #import pdb
                #pdb.set_trace()
                editar_estado = EditarEstadoIntervencion(self,
                    self.lista_intervenciones[pos])
            else:
                print "No puedo"
                errores = ["No se puede cambiar el estado por: estos motivos:",
                        "La intervencion no esta asignada a este grupo, ó.",
                        "La intervencion esta en estado Resuelta o Finalizada."]
                msj = MensajeDeError("\n".join(errores), self.padre.window)
                msj.run()
                """
            editar_estado = EditarEstadoIntervencion(self,
                    self.lista_intervenciones[pos])
                    """
        else:
             error = "Para editar el estado debe seleccionar la intervencion"
             msj = MensajeDeError(error, self.padre.window)
             msj.run()

    def close(self, widget):
        """Cancelación de la operación."""
        close(self.padre.window)
